import Foundation

public enum SyntaxLanguage: String, CaseIterable {
    // MARK: - Cases
    case swift
    case javascript
    case typescript
    case python
    case java
    case kotlin
    case ruby
    case go
    case rust
    case cpp
    case c
    case csharp
    case php
    case html
    case css
    case scss
    case less
    case xml
    case json
    case yaml
    case markdown
    case sql
    case shell
    case bash
    case zsh
    case dockerfile
    case plaintext
    
    // MARK: - Display Names
    public var displayName: String {
        switch self {
        case .swift: return "Swift"
        case .javascript: return "JavaScript"
        case .typescript: return "TypeScript"
        case .python: return "Python"
        case .java: return "Java"
        case .kotlin: return "Kotlin"
        case .ruby: return "Ruby"
        case .go: return "Go"
        case .rust: return "Rust"
        case .cpp: return "C++"
        case .c: return "C"
        case .csharp: return "C#"
        case .php: return "PHP"
        case .html: return "HTML"
        case .css: return "CSS"
        case .scss: return "SCSS"
        case .less: return "Less"
        case .xml: return "XML"
        case .json: return "JSON"
        case .yaml: return "YAML"
        case .markdown: return "Markdown"
        case .sql: return "SQL"
        case .shell: return "Shell"
        case .bash: return "Bash"
        case .zsh: return "Zsh"
        case .dockerfile: return "Dockerfile"
        case .plaintext: return "Plain Text"
        }
    }
    
    // MARK: - File Extensions
    public var fileExtensions: [String] {
        switch self {
        case .swift: return ["swift"]
        case .javascript: return ["js", "jsx", "mjs", "cjs"]
        case .typescript: return ["ts", "tsx"]
        case .python: return ["py", "pyw", "pyi", "pyx"]
        case .java: return ["java"]
        case .kotlin: return ["kt", "kts"]
        case .ruby: return ["rb", "rbw", "rake", "gemspec"]
        case .go: return ["go"]
        case .rust: return ["rs", "rlib"]
        case .cpp: return ["cpp", "cc", "cxx", "hpp", "hxx", "h++", "hh"]
        case .c: return ["c", "h"]
        case .csharp: return ["cs"]
        case .php: return ["php", "php3", "php4", "php5", "phtml"]
        case .html: return ["html", "htm", "xhtml"]
        case .css: return ["css"]
        case .scss: return ["scss"]
        case .less: return ["less"]
        case .xml: return ["xml", "xsl", "xsd", "svg"]
        case .json: return ["json"]
        case .yaml: return ["yml", "yaml"]
        case .markdown: return ["md", "markdown", "mdown", "mkd"]
        case .sql: return ["sql"]
        case .shell: return ["sh"]
        case .bash: return ["bash"]
        case .zsh: return ["zsh"]
        case .dockerfile: return ["dockerfile"]
        case .plaintext: return ["txt"]
        }
    }
    
    // MARK: - Keywords
    public var keywords: [String] {
        switch self {
        case .swift:
            return [
                // 声明关键字
                "class", "struct", "enum", "protocol", "extension",
                "actor", "init", "deinit", "func", "let", "var",
                "associatedtype", "typealias",
                
                // 语句关键字
                "if", "else", "switch", "case", "default", "where",
                "for", "while", "repeat", "do", "break", "continue",
                "fallthrough", "return", "throw", "defer", "guard",
                
                // 表达式关键字
                "as", "is", "try", "catch", "throws", "rethrows",
                "await", "async", "any", "some",
                
                // 修饰符关键字
                "public", "private", "fileprivate", "internal", "open",
                "final", "static", "dynamic", "lazy", "optional",
                "required", "convenience", "mutating", "nonmutating",
                "override", "weak", "unowned", "indirect",
                
                // 特殊关键字
                "self", "super", "nil", "true", "false", "_", "#"
            ]
            
        case .javascript, .typescript:
            return [
                // 声明关键字
                "var", "let", "const", "function", "class", "interface",
                "type", "enum", "namespace", "module",
                
                // 语句关键字
                "if", "else", "switch", "case", "default", "for",
                "while", "do", "break", "continue", "return", "with",
                
                // 异常处理
                "try", "catch", "finally", "throw",
                
                // 模块关键字
                "import", "export", "default", "from", "as",
                
                // 异步关键字
                "async", "await", "yield",
                
                // 类相关
                "constructor", "extends", "implements", "super", "this",
                "new", "instanceof", "typeof",
                
                // 访问修饰符
                "public", "private", "protected", "readonly", "static",
                
                // 特殊值
                "true", "false", "null", "undefined", "void",
                
                // TypeScript 特有
                "declare", "abstract", "keyof", "typeof", "never",
                "unknown", "any", "infer"
            ]
            
        case .python:
            return [
                // 声明关键字
                "def", "class", "lambda", "global", "nonlocal",
                
                // 流程控制
                "if", "elif", "else", "for", "while", "break",
                "continue", "return", "yield", "pass", "match", "case",
                
                // 异常处理
                "try", "except", "finally", "raise", "assert",
                
                // 导入相关
                "import", "from", "as", "with",
                
                // 逻辑运算
                "and", "or", "not", "is", "in",
                
                // 异步相关
                "async", "await",
                
                // 特殊值
                "True", "False", "None"
            ]
            
        case .java:
            return [
                // 声明关键字
                "class", "interface", "enum", "package", "import",
                
                // 访问修饰符
                "public", "private", "protected", "default", "static",
                "final", "abstract", "synchronized", "volatile",
                "transient", "native",
                
                // 基本类型
                "void", "boolean", "byte", "char", "short", "int",
                "long", "float", "double",
                
                // 流程控制
                "if", "else", "switch", "case", "default", "for",
                "while", "do", "break", "continue", "return",
                
                // 异常处理
                "try", "catch", "finally", "throw", "throws",
                
                // 其他关键字
                "new", "instanceof", "super", "this", "extends",
                "implements", "assert",
                
                // 特殊值
                "true", "false", "null"
            ]
            
        case .kotlin:
            return [
                // 声明关键字
                "class", "interface", "object", "fun", "val", "var",
                "constructor", "init",
                
                // 修饰符
                "public", "private", "protected", "internal", "open",
                "final", "abstract", "sealed", "const", "lateinit",
                "override", "suspend",
                
                // 流程控制
                "if", "else", "when", "while", "for", "do", "break",
                "continue", "return", "throw",
                
                // 异常处理
                "try", "catch", "finally",
                
                // 其他关键字
                "as", "is", "in", "!in", "by", "get", "set",
                "delegate", "dynamic", "actual", "expect", "reified",
                "noinline", "crossinline", "vararg", "infix",
                "operator", "data", "inline", "inner", "tailrec",
                "external", "annotation", "companion", "enum",
                "value", "where",
                
                // 特殊值
                "true", "false", "null"
            ]
            
        case .html:
            return [
                // HTML5 标签
                "html", "head", "body", "meta", "title", "link",
                "script", "style", "div", "span", "p", "a", "img",
                "ul", "ol", "li", "table", "tr", "td", "th", "form",
                "input", "button", "select", "option", "textarea",
                "header", "footer", "nav", "main", "section", "article",
                "aside", "figure", "figcaption", "video", "audio",
                "source", "canvas", "svg",
                
                // 常用属性
                "class", "id", "style", "href", "src", "alt", "title",
                "type", "value", "name", "placeholder", "required",
                "disabled", "checked", "selected", "readonly",
                "data-", "aria-"
            ]
            
        case .css, .scss, .less:
            return [
                // 选择器相关
                "root", "hover", "active", "focus", "visited", "link",
                "first-child", "last-child", "nth-child", "not",
                "before", "after",
                
                // 媒体查询
                "media", "screen", "print", "all", "only",
                
                // 动画相关
                "keyframes", "from", "to", "animation", "transition",
                
                // 其他关键字
                "import", "charset", "namespace", "supports",
                "document", "page", "font-face", "viewport",
                
                // SCSS/Less 特有
                "mixin", "include", "extend", "if", "else", "for",
                "each", "while", "function", "return"
            ]
            
        case .sql:
            return [
                // DDL
                "CREATE", "ALTER", "DROP", "TRUNCATE", "RENAME",
                
                // DML
                "SELECT", "INSERT", "UPDATE", "DELETE", "MERGE",
                
                // 查询子句
                "FROM", "WHERE", "GROUP BY", "HAVING", "ORDER BY",
                "LIMIT", "OFFSET",
                
                // 连接
                "JOIN", "INNER JOIN", "LEFT JOIN", "RIGHT JOIN",
                "FULL JOIN", "CROSS JOIN",
                
                // 条件运算
                "AND", "OR", "NOT", "IN", "BETWEEN", "LIKE", "IS NULL",
                "IS NOT NULL",
                
                // 聚合函数
                "COUNT", "SUM", "AVG", "MAX", "MIN",
                
                // 事务控制
                "BEGIN", "COMMIT", "ROLLBACK", "SAVEPOINT",
                
                // 其他
                "DISTINCT", "UNION", "INTERSECT", "EXCEPT", "AS",
                "WITH", "CASE", "WHEN", "THEN", "ELSE", "END"
            ]
            
        default:
            return []
        }
    }
    
    // MARK: - Types
    public var types: [String] {
        switch self {
        case .swift:
            return [
                // 基本类型
                "Int", "UInt", "Float", "Double", "Bool", "String",
                "Character", "Void",
                
                // 集合类型
                "Array", "Dictionary", "Set", "Range", "ClosedRange",
                
                // 可选类型
                "Optional", "Result",
                
                // 错误处理
                "Error", "Never",
                
                // 其他常用类型
                "Any", "AnyObject", "Codable", "Hashable", "Equatable",
                "Comparable", "Sequence", "Collection", "Identifiable"
            ]
            
        case .javascript, .typescript:
            return [
                // JavaScript 基本类型
                "String", "Number", "Boolean", "Symbol", "BigInt",
                "Object", "Function", "undefined", "null",
                
                // 内置对象
                "Array", "Map", "Set", "WeakMap", "WeakSet", "Date",
                "RegExp", "Promise", "Proxy", "Reflect",
                
                // TypeScript 特有类型
                "any", "unknown", "never", "void", "object", "enum",
                "tuple", "union", "intersection", "keyof", "typeof",
                "partial", "readonly", "record", "pick", "omit",
                "exclude", "extract", "parameters", "returntype"
            ]
            
        case .python:
            return [
                // 基本类型
                "str", "int", "float", "bool", "complex", "bytes",
                "bytearray",
                
                // 集合类型
                "list", "tuple", "dict", "set", "frozenset",
                
                // 其他内置类型
                "object", "type", "None", "NotImplemented", "Ellipsis",
                
                // 常用类型提示
                "Optional", "Union", "Any", "Callable", "Iterator",
                "Iterable", "Sequence", "Mapping", "TypeVar", "Generic"
            ]
            
        default:
            return []
        }
    }
    
    // MARK: - Operators
    public var operators: [String] {
        switch self {
        case .swift:
            return [
                // 算术运算符
                "+", "-", "*", "/", "%", "+=", "-=", "*=", "/=", "%=",
                
                // 比较运算符
                "==", "!=", ">", "<", ">=", "<=", "===", "!==",
                
                // 逻辑运算符
                "&&", "||", "!",
                
                // 范围运算符
                "...", "..<",
                
                // 其他运算符
                "??", "?", "!", "->", "&", "|", "^", "~", ">>", "<<"
            ]
            
        case .javascript, .typescript:
            return [
                // 算术运算符
                "+", "-", "*", "/", "%", "++", "--", "**",
                
                // 赋值运算符
                "=", "+=", "-=", "*=", "/=", "%=", "**=",
                
                // 比较运算符
                "==", "===", "!=", "!==", ">", "<", ">=", "<=",
                
                // 逻辑运算符
                "&&", "||", "!", "??",
                
                // 位运算符
                "&", "|", "^", "~", "<<", ">>", ">>>",
                
                // 其他运算符
                "?", ":", "=>", "...", "?.", "??"
            ]
            
        default:
            return []
        }
    }
    
    // MARK: - Comment Patterns
    public var commentPatterns: [String] {
        switch self {
        case .swift:
            return [
                "//.*$",  // 单行注释
                "/\\*[^*]*\\*+(?:[^/*][^*]*\\*+)*/",  // 多行注释
                "///.*$"  // 文档注释
            ]
            
        case .javascript, .typescript:
            return [
                "//.*$",  // 单行注释
                "/\\*[^*]*\\*+(?:[^/*][^*]*\\*+)*/",  // 多行注释
                "///.*$"  // TypeScript 文档注释
            ]
            
        case .python:
            return [
                "#.*$",  // 单行注释
                "'''[\\s\\S]*?'''",  // 多行注释（单引号）
                "\"\"\"[\\s\\S]*?\"\"\"",  // 多行注释（双引号）
            ]
            
        case .html:
            return [
                "<!--[\\s\\S]*?-->"  // HTML 注释
            ]
            
        case .css, .scss, .less:
            return [
                "/\\*[^*]*\\*+(?:[^/*][^*]*\\*+)*/"  // CSS 注释
            ]
            
        default:
            return []
        }
    }
    
    // MARK: - String Patterns
    public var stringPatterns: [String] {
        switch self {
        case .swift:
            return [
                "\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"",  // 双引号字符串
                "\"\"\"[\\s\\S]*?\"\"\"",  // 多行字符串
            ]
            
        case .javascript, .typescript:
            return [
                "\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"",  // 双引号字符串
                "'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'",  // 单引号字符串
                "`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`"  // 模板字符串
            ]
            
        case .python:
            return [
                "\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\"",  // 双引号字符串
                "'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'",  // 单引号字符串
                "'''[\\s\\S]*?'''",  // 三引号字符串（单引号）
                "\"\"\"[\\s\\S]*?\"\"\"",  // 三引号字符串（双引号）
            ]
            
        default:
            return []
        }
    }
    
    // MARK: - Factory Methods
    public static func detect(from fileExtension: String) -> SyntaxLanguage {
        let lowercasedExtension = fileExtension.lowercased()
        for language in SyntaxLanguage.allCases {
            if language.fileExtensions.contains(lowercasedExtension) {
                return language
            }
        }
        return .plaintext
    }
} 
